package n90_JDK线程池;

import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

import static utils.Sleeper.sleep;

/**
 * @author fu
 * @date 2022-03-30 21:53
 * 概要：
 * ---------------------------------------------------------------
 * |                                                              |
 * |                  |
 * |                                                             |
 * |=============================================================
 */
@Slf4j(topic = "c.T2")
public class T2_Executors提交任务 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        _test_submit();
//        _test_invokeAll();
        _test_invokeAny();

    }

    /**
     * submit保护性暂停 接收 另一个线程运行的结果
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void _test_submit() throws ExecutionException, InterruptedException {

        final ExecutorService pool = Executors.newFixedThreadPool(2);

        final Future<String> future = pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.debug("running......");
                sleep(1);
                return "返回结果是OK";
            }
        });

        // 这里的get 会阻塞等待！
        log.debug("{}", future.get());
    }

    /**
     * invokeAll 提交tasks 中所有任务
     *  等所有任务结束了 才一起返回值
     *
     *  打印结果发现，前面两个在核心线程里先执行，第三个进入队列 等待最先结束的核心线程去 执行第三个
     *  总共花费得时间：最先结束[线程1]用1s + [线程1]之后执行队列里的第三个用3s = 4s
     */
    private static void _test_invokeAll() throws InterruptedException {

        // 创建几个 有返回值的任务
        final List<Callable<String>> callableList = Arrays.asList(
                () -> {
                    log.debug("begin1");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    log.debug("begin2");
                    Thread.sleep(2000);
                    return "2";
                },
                () -> {
                    log.debug("begin3");
                    Thread.sleep(3000);
                    return "3";
                });

        // 创建两个核心线程 并无界的线程池
        final ExecutorService pool = Executors.newFixedThreadPool(2);
        final List<Future<String>> futureList = pool.invokeAll(callableList);

        // 遍历这个 保护性暂停的结果
        futureList.forEach(f->{
            try {
                log.debug("结果：{}",f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }


    /**
     * invokeAny 提交tasks 中所有任务 【返回一个最先得到的结果，其它任务取消】
     */
    private static void _test_invokeAny() throws ExecutionException, InterruptedException {
        // 创建几个 有返回值的任务
        final List<Callable<String>> callableList = Arrays.asList(
                () -> {
                    log.debug("begin1");
                    Thread.sleep(1000);
                    log.debug("end--1");
                    return "1";
                },
                () -> {
                    log.debug("begin2");
                    Thread.sleep(2000);
                    log.debug("end--2");
                    return "2";
                },
                () -> {
                    log.debug("begin3");
                    Thread.sleep(3000);
                    log.debug("end--3");
                    return "3";
                });

        // 创建两个核心线程 并无界的线程池
        final ExecutorService pool = Executors.newFixedThreadPool(2);

        final String s = pool.invokeAny(callableList);
        log.debug("结果是：{}",s);
    }












}


